home *** CD-ROM | disk | FTP | other *** search
/ Info-Mac 4 / Info_Mac IV CD-ROM (Pacific HiTech Inc.)(August 1994).iso / Development / Source / Telnet 2.6.1d1 4⁄26⁄94 Folder / source / tek / tekrgmac.c < prev    next >
Text File  |  1994-04-18  |  13KB  |  580 lines
  1. /*
  2. rgmac.c by Gaige B. Paulsen
  3.   spawned from rgp.c by Aaron Contorer for NCSA
  4. Copyright 1987, board of trustees, University of Illinois
  5.  
  6. Routines for Macintosh Window output.  
  7. */
  8.  
  9. #ifdef MPW
  10. #pragma segment TEKMAIN
  11. #endif
  12.  
  13. #include <stdio.h>
  14. #include <String.h>
  15. #include <Packages.h>
  16.  
  17. #include "tekrgmac.proto.h"
  18. #include "TelnetHeader.h"
  19. #include "maclook.proto.h"
  20. #include "vgtek.proto.h"
  21. #include "mydnr.proto.h"
  22. #include "rsmac.proto.h"
  23. #include "netevent.proto.h"
  24. #include "rg0.proto.h"
  25. #include "rgmp.proto.h"
  26. #include "InternalEvents.h"
  27. #include "tekdefs.h"        /* NCSA: sb - all the TEK defines are now here */
  28.  
  29. #define TEK_DEBUG1
  30. #ifdef    TEK_DEBUG1
  31. #include "debug.h"
  32. #define    TEK_DEBUG_PRINT(x)    putln(x)
  33. char    TEK_DEBUG_STRING    [512];
  34. #else
  35. #define    TEK_DEBUG(x)
  36. #endif
  37.  
  38. /*--------------------------------------------------------------------------*/
  39. /* Some variable definitions are needed before we give the code                */
  40. /*                                                                             */
  41. /*--------------------------------------------------------------------------*/
  42.  
  43. long    RGMlastclick;
  44. short    RGMcolor[]=
  45.     { 30,            /* black */
  46.       33,            /* white */
  47.       205,            /* red */
  48.       341,            /* green */
  49.       409,            /* blue */
  50.       273,            /* cyan */
  51.       137,            /* magenta */
  52.       69            /* yellow */
  53.       };
  54.  
  55. struct    RGMwindows *RGMwind[ MAXWIND ];
  56.  
  57. char    *RGMdevname(void)
  58. {
  59.     return("Macintosh Windows");
  60. }
  61.  
  62. short    RGMnewwin(void)
  63. {
  64.     short    i = 0;
  65.  
  66.     while ((i < MAXWIND) && (RGMwind[i]->inuse)) i++;
  67.  
  68.     if (i >= MAXWIND) return(-1);
  69.  
  70.     RGMwind[i]->wind = GetNewWindow(256, NULL, kInFront);
  71.     if (RGMwind[i]->wind == 0L) return(-1);
  72.  
  73.     ((WindowPeek)RGMwind[i]->wind)->windowKind = WIN_TEK;
  74.     
  75.     RGMwind[i]->vg = -1;                /* BYU */
  76.     RGMwind[i]->vs = -1;                /* BYU */
  77.     RGMwind[i]->xorigin = 0;
  78.     RGMwind[i]->yorigin = 0;
  79.     RGMwind[i]->xscale  = WINXMAX;    /* BYU LSC - need the "W" here */
  80.     RGMwind[i]->yscale  = WINYMAX;    /* BYU LSC - need the "W" here */
  81.     RGMwind[i]->width   = 400;        /* BYU LSC - was 256 (size of old window resource */
  82.     RGMwind[i]->height  = 300;        /* BYU LSC - was 342 (size of old window resource */
  83.     RGMwind[i]->inuse   = TRUE;
  84.     RGMwind[i]->ingin   = 0;        /* BYU LSC */
  85.  
  86.     ValidRect(&RGMwind[i]->wind->portRect);  
  87.  
  88.     return(i);
  89. }
  90.  
  91. void    RGMinit(void)
  92. {
  93.     short    i;
  94.     for (i = 0; i < MAXWIND; i++)
  95.         RGMwind[i]->inuse = 0;
  96. }
  97.  
  98. short    RGMgin(short w)
  99. {
  100.     if (RGsetwind(w)) return(-1);
  101.  
  102.     setgraphcurs();
  103.     RGMwind[w]->ingin=1;
  104. }
  105.  
  106. short    RGMpencolor(short w, short color)
  107. {
  108.     if (RGsetwind(w) ) return(-1);
  109.     ForeColor((long) RGMcolor[color] );
  110. #ifdef    TEK_DEBUG_1
  111.     sprintf(TEK_DEBUG_STRING, "TEK: Setting pen color to %d", color);
  112.     putln(TEK_DEBUG_STRING);
  113. #endif
  114.  
  115. }
  116.  
  117. short    RGMclrscr(short w)
  118. {    
  119.     if (RGsetwind(w) ) return(-1);
  120.     PaintRect(&RGMwind[w]->wind->portRect);
  121.     TEK_DEBUG_PRINT("TEK: Clearing screen");                    
  122. }    
  123.  
  124. short    RGMclose(short w)
  125. {
  126.     if (RGsetwind(w) ) return(-1);
  127.  
  128.     DisposeWindow(RGMwind[w]->wind);
  129.     RGMwind[w]->inuse  = FALSE;
  130. }
  131.  
  132. short    RGMpoint(short w, short x, short y)
  133. {
  134.     if (RGsetwind(w) ) return(-1);
  135.  
  136.     MoveTo(x,y);
  137.     LineTo(x,y);
  138. } 
  139.  
  140. short    RGMdrawline(short w, short x0, short y0, short x1, short y1)
  141. {
  142.     long    xl0, yl0, xl1, yl1;
  143.     
  144.     if (RGsetwind(w) )
  145.         return(-1);
  146.  
  147.     xl0 = ((long)x0 * RGMwind[w]->width) / INXMAX;
  148.     yl0 = (long)RGMwind[w]->height - (((long)y0 * RGMwind[w]->height) / INYMAX);
  149.     xl1 = ((long)x1 * RGMwind[w]->width) / INXMAX;
  150.     yl1 = (long)RGMwind[w]->height - (((long)y1 * RGMwind[w]->height) / INYMAX);
  151.  
  152.     MoveTo((short)xl0, (short)yl0);
  153.     LineTo((short)xl1, (short)yl1);
  154. }
  155.  
  156. void    RGMinfo(short w, short v, short a, short b, short c, short d)
  157. {
  158. #pragma unused(a, b, c, d)
  159.     RGMwind[w]->vg=v;
  160. }
  161.  
  162. void    RGMpagedone(short w)
  163. {
  164. #pragma unused(w)
  165. }
  166.  
  167. void    RGMdataline(short w, short data, short count)
  168. {
  169. #pragma unused(w, data, count)
  170. }
  171.  
  172.  
  173. void    RGMcharmode(short w, short rotation, short size)
  174. {
  175. #pragma unused(w, rotation, size)
  176. }
  177.  
  178. void    RGMgmode(void)
  179. {}
  180.  
  181. void    RGMtmode(void)
  182. {}
  183.  
  184. void    RGMshowcur(void)
  185. {
  186. }
  187.  
  188. void    RGMlockcur(void)
  189. {
  190. }
  191.  
  192. void    RGMhidecur(void)
  193. {
  194. }
  195.  
  196. void    RGMbell(short w)
  197. {
  198. #pragma unused(w)
  199. }
  200.  
  201. void    RGMuncover(short w)
  202. {
  203. #pragma unused(w)
  204. }
  205.  
  206. short    RGMoutfunc(short (*f )())
  207. {
  208. #pragma unused(f)
  209.     return(0);    // Unused
  210. }
  211.  
  212. Boolean RGMalloc(void)        /* BYU - allocate this structure to save global space */
  213. {
  214.     short i;
  215.     for(i=0; i<MAXWIND; i++) {        /* BYU */
  216.         RGMwind[i] = (struct RGMwindows *) NewPtrClear(sizeof(struct RGMwindows));    /* BYU */
  217.         if (RGMwind[i]) {                        /* BYU */
  218.             RGMwind[i]->wind = (GrafPtr) 0;        /* BYU */
  219.             RGMwind[i]->id = 'RGMW';
  220.             RGMwind[i]->vg = -1;                /* BYU - necessary */
  221.             RGMwind[i]->vs = -1;                /* BYU */
  222.             RGMwind[i]->inuse = 0;                /* BYU - necessary */
  223.         } else                                     /* BYU */
  224.             return (TRUE);                /* BYU - insufficient memory */
  225.     }
  226.     return(FALSE);
  227. }
  228.  
  229. short    RGsetwind(short dnum)
  230. {
  231.     if (dnum<0 || dnum>=MAXWIND) return(-1);
  232.  
  233.     if (!RGMwind[dnum]->inuse) return(-1);
  234.  
  235.     SetPort( RGMwind[dnum]->wind);
  236.     return(0);
  237. }
  238.  
  239. short    RGfindbyVG(short vg)
  240. {
  241.     short    i = 0;
  242.  
  243.     while ((i < MAXWIND) && ((!RGMwind[i]->inuse) || (RGMwind[i]->vg != vg)))
  244.         i++;
  245.     if (i >= MAXWIND) return(-1);
  246.     return(i);
  247. }
  248.  
  249. short    RGattach(short vg, short virt, char *name, short TEKtype)
  250. {
  251.     short            dnum;
  252.     unsigned long    time;
  253.     char            myname[256],ts[256];
  254.  
  255.     if ((dnum = RGfindbyVG(vg)) < 0) return(-1);
  256.  
  257.     RGMwind[dnum]->vs = virt;
  258.     RGMwind[dnum]->name = (unsigned char *) NewPtrClear((long) 256);        /* BYU LSC */
  259.  
  260.     if (RGMwind[dnum]->name == 0L) return(-2);
  261.  
  262.     myname[0] = '•';
  263.     if (TEKtype)
  264.         strcpy(&myname[1], "[4105] ");
  265.     else
  266.         strcpy(&myname[1], "[4014] ");
  267.         
  268.     strncpy(&myname[strlen(myname)],name,120);
  269.  
  270.     GetDateTime(&time);
  271.     IUTimeString(time,FALSE,(StringPtr) ts);        /* BYU LSC - Put time in the temp string */
  272.     p2cstr((StringPtr)ts);                                            /* BYU LSC */
  273.  
  274.     strncat(myname,"  ",2);                /* BYU - was 4 - Space, please */
  275.     strncat(myname,ts,64);                /* BYU - Place the time string at the end */
  276.     strcpy((char *) RGMwind[dnum]->name,myname);    /* BYU LSC */
  277.  
  278.     if (RGMwind[dnum]->wind != (GrafPtr) 0) {    /* BYU LSC */
  279.         c2pstr(myname);                            /* BYU LSC */
  280.         SetWTitle(RGMwind[dnum]->wind,(StringPtr)myname);    /* BYU LSC */
  281.     }
  282.  
  283.     return(0);
  284. }
  285.  
  286.  
  287. short    RGdetach( short vg)
  288. {
  289.         short    dnum;            /* BYU */
  290.         char    myname[256];            /* BYU LSC */
  291.  
  292.     if ((dnum = RGfindbyVG(vg)) < 0) return(-1);        /* BYU */
  293.     if (dnum >= MAXWIND)  return(-1);                    /* BYU */
  294.  
  295.     if (RGMwind[dnum]->vs != -1) {                                     /* BYU */
  296.         if (RGMwind[dnum]->wind != (GrafPtr) 0) {                    /* BYU */
  297. #if 1
  298.             strncpy((char *) RGMwind[dnum]->name,                /* BYU LSC */
  299.                     (char *) &RGMwind[dnum]->name[1],255);        /* BYU LSC */
  300.             strncpy(myname, (char *) RGMwind[dnum]->name,256);    /* BYU LSC */
  301.             c2pstr(myname);                                        /* BYU LSC */
  302.             SetWTitle(RGMwind[dnum]->wind,(StringPtr)myname);                /* BYU LSC */
  303. #else
  304.             strncpy((char *) RGMwind[dnum]->name,                /* BYU LSC */
  305.                     (char *) &RGMwind[dnum]->name[1],255);        /* BYU LSC */
  306.             SetWTitle(RGMwind[dnum]->wind,RGMwind[dnum]->name);    /* BYU LSC */
  307. #endif
  308.         }                            /* BYU */
  309.     }                                /* BYU */
  310.     return(0);                        /* BYU */
  311. }
  312.  
  313. short    RGfindbywind( GrafPtr wind)
  314. {
  315.     short    i = 0;
  316.  
  317.     while ((i < MAXWIND) && ((!RGMwind[i]->inuse) || (RGMwind[i]->wind != wind)))
  318.         i++;
  319.     if (i >= MAXWIND) return(-1);
  320.     return(i);
  321. }
  322.  
  323. short    RGupdate( GrafPtr wind)
  324. {
  325.     short    i = 0,
  326.             done;
  327.  
  328.     if ((i = RGfindbywind(wind)) < 0)
  329.         return(-1);
  330.  
  331.     SetPort(wind);
  332.     BeginUpdate(wind);
  333.  
  334.     VGstopred(RGMwind[i]->vg);
  335.     VGpage(RGMwind[i]->vg);
  336.     done = VGpred(RGMwind[i]->vg,RGMwind[i]->vg);
  337.  
  338.     EndUpdate(wind);
  339.     if (!done)
  340.         netputevent(USERCLASS,RG_REDRAW,RGMwind[i]->vg,0);
  341.     return(done);
  342. }
  343.  
  344. short    RGsupdate( short i)
  345. {
  346.     short    rg;
  347.  
  348.     rg = RGfindbyVG(i);
  349.  
  350.     if (rg < 0) return(0);
  351.     SetPort(RGMwind[rg]->wind);
  352.     if (!VGpred(RGMwind[rg]->vg,RGMwind[rg]->vg))
  353.     {
  354.         netputevent(USERCLASS,RG_REDRAW,i,0);
  355.     }
  356.     else
  357.         return(1);
  358.     return(0);
  359. }
  360.  
  361. short    RGgetVG(GrafPtr wind)
  362. {
  363.     short    i;
  364.  
  365.     i = RGfindbywind(wind);
  366.  
  367.     return(RGMwind[i]->vg);
  368. }
  369.  
  370. short    RGgetdnum(GrafPtr wind)
  371. {
  372.     return(RGfindbywind(wind));
  373. }
  374.  
  375. short    RGgetVS(short dnum)
  376. {
  377.     return(RGMwind[dnum]->vs);
  378. }
  379.  
  380. short    inSplash(Point *p1, Point *p2)
  381. {
  382.     if ((p1->h - p2->h > 3) || (p2->h - p1->h > 3))
  383.         return(0);
  384.     if ((p1->v - p2->v > 3) || (p2->v - p1->v > 3))
  385.         return(0);
  386.  
  387.     return(1);
  388. }
  389.  
  390. void VidSync( void)
  391. {
  392.     long    a;
  393.     a = TickCount();            /* BYU LSC */
  394.     while (a == TickCount());    /* BYU LSC */
  395. }
  396.  
  397. void RGmousedown
  398.   (
  399.     GrafPtr wind,
  400.     Point *wherein
  401.   )
  402. {
  403.     unsigned long    lx,ly;        /* NCSA: SB */
  404.     char            thispaceforent[6];
  405.     short            i;
  406.     Point            where;
  407.     char            dum[32];
  408.  
  409.     where = *wherein;
  410.     if ((i = RGfindbywind(wind)) < 0)
  411.         return;
  412.  
  413.     if (!RGMwind[i]->ingin)
  414.     {
  415.     Point    anchor,current,last;
  416. #if 0                            /* BYU LSC - was "#ifndef MPW" */
  417.     long    TickCount();
  418. #endif MPW
  419.     long    tc;
  420.     short    x0,y0,x1,y1;
  421.     Rect    rect;
  422.     
  423.         SetPort(wind);
  424.     
  425.         last  = where;
  426.         current = where;
  427.         anchor = where;
  428.     
  429.         PenPat(PATTERN(qd.gray));    
  430.         PenMode(patXor);
  431.     
  432.         SetRect(&rect,0,0,0,0);
  433.     
  434.         while (StillDown())
  435.         {
  436.             GetMouse(¤t);
  437.             if (inSplash(¤t,&anchor)) continue;
  438.             tc = TickCount();
  439.             while(TickCount() == tc);
  440.             VidSync();
  441.             FrameRect(&rect);
  442.     
  443.             if (anchor.v < current.v)
  444.             {
  445.                 rect.top = anchor.v;
  446.                 rect.bottom = current.v;
  447.             }
  448.             else
  449.             {
  450.                 rect.top = current.v;
  451.                 rect.bottom = anchor.v;
  452.             }
  453.     
  454.             if (anchor.h < current.h)
  455.             {
  456.                 rect.left = anchor.h;
  457.                 rect.right = current.h;
  458.             }
  459.             else
  460.             {
  461.                 rect.right = anchor.h;
  462.                 rect.left = current.h;
  463.             }
  464.     
  465.             FrameRect(&rect);
  466.             last = current;
  467.         }
  468.     
  469.         FrameRect(&rect);
  470.  
  471.         PenPat(PATTERN(qd.black));    
  472.         PenMode(patCopy);
  473.  
  474.         if (!inSplash(&anchor,¤t))
  475.         {
  476.             x0 = (short) ((long) rect.left * RGMwind[i]->xscale / RGMwind[i]->width );
  477.             y0 = (short) (RGMwind[i]->yscale -
  478.                     (long) rect.top * RGMwind[i]->yscale / RGMwind[i]->height);
  479.             x1 = (short) ((long) rect.right * RGMwind[i]->xscale / RGMwind[i]->width);
  480.             y1 = (short) (RGMwind[i]->yscale -
  481.                     (long) rect.bottom * RGMwind[i]->yscale / RGMwind[i]->height);
  482.             x1 = (x1 < x0+2) ? x0 + 4 : x1;
  483.             y0 = (y0 < y1+2) ? y1 + 4 : y0;
  484.  
  485.             VGzoom( i,
  486.                     x0 + RGMwind[i]->xorigin,
  487.                     y1 + RGMwind[i]->yorigin,
  488.                     x1 + RGMwind[i]->xorigin,
  489.                     y0 + RGMwind[i]->yorigin);
  490.  
  491.             VGpage(RGMwind[i]->vg);
  492.  
  493.             RGMwind[i]->xscale  = x1 - x0;
  494.             RGMwind[i]->yscale  = y0 - y1;
  495.             RGMwind[i]->xorigin = x0 + RGMwind[i]->xorigin;
  496.             RGMwind[i]->yorigin = y1 + RGMwind[i]->yorigin;
  497.  
  498.             while(!VGpred(RGMwind[i]->vg,RGMwind[i]->vg))
  499.                 Stask();
  500.             RGMlastclick = 0L;
  501.         }
  502.         else
  503.         {
  504.             if (RGMlastclick && ((RGMlastclick + GetDblTime()) > TickCount()))
  505.             {
  506.                 RGMwind[i]->xscale  = WINXMAX;    /* BYU LSC - need the "W" here */
  507.                 RGMwind[i]->yscale  = WINYMAX;    /* BYU LSC - need the "W" here */
  508.                 RGMwind[i]->xorigin = 0;
  509.                 RGMwind[i]->yorigin = 0;
  510.  
  511.                 VGzoom(i,0,0,WINXMAX-1,WINYMAX-1);    /* BYU LSC - need the "W" here */
  512.                 VGpage( RGMwind[i]->vg);
  513.                 while(!VGpred(RGMwind[i]->vg,RGMwind[i]->vg))
  514.                     Stask();
  515.                 RGMlastclick = 0L;
  516.             }
  517.             else RGMlastclick = TickCount();
  518.         }
  519.         return;
  520.     
  521.     }
  522.     
  523.     /* NCSA: SB */
  524.     /* NCSA: SB - These computations are being truncated and turned into signed ints. */
  525.     /* NCSA: SB - Just make sure everything is cast correctly, and were fine */
  526.     
  527.     lx = ((unsigned long)RGMwind[i]->xscale * (unsigned long)where.h)     /* NCSA: SB */
  528.             / (unsigned long)RGMwind[i]->width;                             /* NCSA: SB */
  529.     ly = (unsigned long)RGMwind[i]->yscale -                             /* NCSA: SB */
  530.         ((unsigned long)RGMwind[i]->yscale * (unsigned long)where.v) / (unsigned long)RGMwind[i]->height; /* NCSA: SB */
  531.  
  532.     VGgindata(RGMwind[i]->vg,(unsigned short) lx,(unsigned short)ly,' ',thispaceforent);    /* NCSA: SB */
  533.  
  534. #if 0                                                    /* BYU LSC - not needed */
  535. sprintf(dum,"GIN i: %d, vs: %d\015",i,RGMwind[i]->vs);    /* BYU 2.4.18 - changed \n to \015 */
  536. putln(dum);
  537. #endif                                                    /* BYU LSC - not needed */
  538.  
  539.     RSsendstring(RGMwind[i]->vs,thispaceforent,5);
  540.     sprintf(dum," \r\n");
  541.     RSsendstring(RGMwind[i]->vs,dum,3);
  542.     
  543.  
  544.     /*    RGMwind[i]->ingin = 0; */
  545.     unsetgraphcurs();
  546.     RGMlastclick = TickCount();
  547. }
  548.  
  549.  
  550. /*--------------------------------------------------------------------------*/
  551. /* NCSA: SB - RGMgrowme                                                        */
  552. /* This allows the TEK window to be grown like any other real window.        */
  553. /* The grow box is not shown on the screen, but it acts accordingly     - SMB    */
  554. /*--------------------------------------------------------------------------*/
  555. void    RGMgrowme(short myRGMnum,GrafPtr window, long *where, short modifiers)
  556. {
  557.     #pragma unused (modifiers)
  558.     long size;
  559.     Rect SizRect;
  560.  
  561.     SetRect(&SizRect, 50, 50, 1500, 1500);            /* NCSA: SB - max size - arbitrary */
  562.  
  563.     if (where)
  564.     {        
  565.         size = GrowWindow(window, *(Point *) where, &SizRect);    
  566.         if (size != 0L)
  567.             {
  568.             SizeWindow(window, size & 0xffff, (size >> 16) & 0xffff, FALSE);
  569.             RGMwind[myRGMnum]->width   = window->portRect.right - window->portRect.left;        
  570.             RGMwind[myRGMnum]->height  = window->portRect.bottom - window->portRect.top;         
  571.             VGpage(RGMwind[myRGMnum]->vg);
  572.             InvalRect(&window->portRect);
  573.             RGupdate(window);
  574.             }
  575.         else
  576.             return;                            /* user skipped growing */
  577.     }
  578. }
  579.  
  580.